package java学习.第08章_面向对象编程_高级;

import org.junit.Test;

/**
 * Java 提供了两个类型系统， 基本数据类型和引用数据类型。
 * 使用基本数据类型在于效率，
 * 然而当要使用针对对象设计的API或新特性（例如泛型）怎么办
 * <p>
 * 基本数据类型    包装类        缓存对象
 * byte    ->   Byte          -128~127
 * short   ->   Short         -128~127
 * int     ->   Integer       -128~127
 * long    ->   Long          -128~127
 * float   ->   Float         无
 * double  ->   Double        无
 * boolean ->   Boolean       0~127
 * char    ->   Character     true和false
 * <p>
 * 包装类:为了使基本数据类型拥有引用数据类型的相关特性
 * 默认值为 null
 */
public class J_包装类 {

    @Test
    public void new基本数据类型的包装类() {
        Integer i1 = 5;
        System.out.println(i1 == 5);//true
        //只要new 用 == 都是false
        Integer i2 = new Integer(5);
        Integer i3 = new Integer(5);
        //false 只要两个基本数据类型比较 比较地址
        System.out.println(i2 == i3);
        //true  i3 自动转成 基本数据类型进行比较
        System.out.println(5 == i3);
        //只要字符串 在忽略大小写情况下   不是true  其他都是false
        Boolean b = new Boolean("true");
    }

    @Test
    public void 基本数据类型包装类的valueOf() {
        /**
         * public static Integer valueOf(int i){
         *  if(i>=-128&&i<=IntegerCache.high)
         *  return IntegerCache.cache[i+128];
         *  else return new Integer(i);
         *  }
         *          享元设计模式
         *  通过看源码能够知道整数类型在-128~127之间时，会使用缓存。
         *  造成的效果就是，如果已经创建了一个相同的整数，
         *  使用valueOf创建第二次时，不会使用new 关键字，
         *  而是用已经缓存的对象。所以使用valueOf方法创建两次对象，
         *  若对应数值相同，且数值在-128~127之间时，两个对象指向同一个地址。
         *  使用Integer i=400这样的方法创建Integer对象与使用valueOf方法的效果是一样的,
         *  若要比较，使用compareTo或者equals方法是更好的
         *
         *
         */
        Integer i1 = Integer.valueOf(5);
        Integer i2 = Integer.valueOf(5);
        System.out.println(i1 == i2);//true
        Integer i3 = Integer.valueOf(128);
        Integer i4 = Integer.valueOf(128);
        System.out.println(i3 == i4);//false
    }

    @Test //JKD 5.0 以上
    public void 自动装箱自动拆箱() {
        Integer ii = new Integer(7);
        int i1 = 5;
        //自动装箱  基本数据类型 -> 引用数据类型
        Integer i2 = 127; //相当于Integer.valueOf(127);
        //自动拆箱  引用数据类型 -> 基本数据类型
        int i0 = ii.intValue();
        int i3 = i2;//相当于 ii.intValue();
        Integer i4 = 127;
        System.out.println(i2 == i4);
    }

    @Test
    public void String与包装类() {
        int i1 = 10;
        String s1 = String.valueOf(i1);//基本数据类型转 String
        String s2 = i1 + "";//这也可以 看着不专业
        System.out.println(s1);

        String s3 = "85";
        int i4 = Integer.parseInt(s3);//String 转 int
        Integer i3 = Integer.valueOf(s3);//String 转 Integer
        System.out.println(i3);

    }

    @Test
    public void 三元运算符的自动拆装箱() {
        /**
         * 三元运算符，会进行类型提升
         * if else 不会
         */
        System.out.println(true ? 1 : 1.0);//输出1.0
        System.out.println(true ? new Integer(1) : new Double(1));//输出1.0
        Object o;
        if(true){
            o=new Integer(1);
        }else {
            o= new Double(1);
        }
        System.out.println(o);//1
    }
}
